{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/mpbast0s/2025-2---PPGEE---INTRODU-O-AO-APRENDIZADO-DE-M-QUINA-/blob/main/codigo_aula6_regressao_linear_multipla.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3f389fa6",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "3f389fa6"
      },
      "source": [
        "# Regressão Linear Múltipla"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "490b4f59",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "490b4f59"
      },
      "source": [
        "## Objetivo\n",
        "Com este código, você irá:\n",
        "- Estender o nosso modelo de regressão para que ele possa contemplar múltiplas características\n",
        "    - Vamos estender a estrutura dos dados para contemplar múltiplas características\n",
        "    - Reescrever a previsão, a função custo e o cálculo do gradiente para contemplar a possibilidade de múltiplas características\n",
        "    - Utilizar a função `np.dot` para vetorizar nossa implementação, para simplificar o código e torná-lo mais rápido."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 125,
      "id": "95ec3b46",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "95ec3b46"
      },
      "outputs": [],
      "source": [
        "import math as math\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "np.set_printoptions(precision=2)  # reduz a precisão das numpy arrays na hora de dar print"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "51bef8ee",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "51bef8ee"
      },
      "source": [
        "# Definição do Problema\n",
        "\n",
        "Usaremos um exemplo de motivação baseado no problema de estimar o preço de uma casa.\n",
        "\n",
        "Os dados de treinamento contêm três exemplos com quatro características (Área, quartos, andares e idade).  Note que a primeira característica possui uma ordem de grandeza muito maior que as demais. Isso causará um problema, mas nós resolveremos isso em códigos futuros.\n",
        "\n",
        "\n",
        "| Área (sqft) | quartos  | andares | Idade | preço (milháres de dólares)  |   \n",
        "| ----------------| ------------------- |----------------- |--------------|-------------- |  \n",
        "| 2104            | 5                   | 1                | 45           | 460           |  \n",
        "| 1416            | 3                   | 2                | 40           | 232           |  \n",
        "| 852             | 2                   | 1                | 35           | 178           |  \n",
        "\n",
        "Você irá construir um modelo de regressão linear usando esses valores de tal forma que você também possa depois estimar o preço de outras casas. Por exemplo, um casa com 1200 sqft, 3 quartos, 1 andares, 40 anos.  \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 126,
      "id": "7aea2489",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "7aea2489"
      },
      "outputs": [],
      "source": [
        "X_trein = np.array([[2104, 5, 1, 45], [1416, 3, 2, 40], [852, 2, 1, 35]])\n",
        "y_trein = np.array([460, 232, 178])"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "85f8ac54",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "85f8ac54"
      },
      "source": [
        "## Dando print na nossa matriz X, que contém nossos exemplos de treinamento"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 127,
      "id": "e8b92e54",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e8b92e54",
        "outputId": "c2d329ea-1953-4568-a7f6-7154e60f25a1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "X Shape: (3, 4), X Type:<class 'numpy.ndarray'>)\n",
            "[[2104    5    1   45]\n",
            " [1416    3    2   40]\n",
            " [ 852    2    1   35]]\n",
            "y Shape: (3,), y Type:<class 'numpy.ndarray'>)\n",
            "[460 232 178]\n"
          ]
        }
      ],
      "source": [
        "print(f\"X Shape: {X_trein.shape}, X Type:{type(X_trein)})\")\n",
        "print(X_trein)\n",
        "print(f\"y Shape: {y_trein.shape}, y Type:{type(y_trein)})\")\n",
        "print(y_trein)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4ff4b596",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "4ff4b596"
      },
      "source": [
        "## Parâmetros $w$ e $b$\n",
        "\n",
        "* $\\mathbf{w}$ é um vetor com $n$ elementos.\n",
        "  - Cada elemento contém um parâmetro associado a uma característica\n",
        "  - Para o nosso conjunto de dados, $n$ é 4 (número de características)\n",
        "  - $b$ é um parâmetro escalar (apenas um único número)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f9bc46dd",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "f9bc46dd"
      },
      "source": [
        "Para demonstração, $\\mathbf{w}$ e $b$ serão carregados com um valor inicial que é próximo do ótimo. $\\mathbf{w}$ é um vetor construído como sendo uma numpy array de 1 dimensão (1-D NumPy array)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 128,
      "id": "8c7be5d2",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8c7be5d2",
        "outputId": "983f4f7a-e73f-4d89-f81b-aa9ce6b9d3c6"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "w_inicial shape: (4,), b_inicial type: <class 'float'>\n"
          ]
        }
      ],
      "source": [
        "b_inicial = 785.1811367994083\n",
        "w_inicial = np.array([ 0.39133535, 18.75376741, -53.36032453, -26.42131618])\n",
        "print(f\"w_inicial shape: {w_inicial.shape}, b_inicial type: {type(b_inicial)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9a7de797",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "9a7de797"
      },
      "source": [
        "# Previsão usando o Modelo com múltiplas características\n",
        "\n",
        "A previsão do modelo com múltiplas características é dada pelo seguinte modelo linear:\n",
        "\n",
        "$$ f_{\\mathbf{w},b}(\\mathbf{x}) =  w_0x_0 + w_1x_1 +... + w_{n-1}x_{n-1} + b \\tag{1}$$\n",
        "\n",
        "ou, usando uma notação vetorial:\n",
        "\n",
        "$$ f_{\\mathbf{w},b}(\\mathbf{x}) = \\mathbf{w} \\cdot \\mathbf{x} + b  \\tag{2} $$\n",
        "\n",
        "onde $\\cdot$ é o produtor escalar (`dot product`)\n",
        "\n",
        "Para demonstrar o produto escalar, iremos implementar a previsão usando (1) e (2)."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0dd44f21",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "0dd44f21"
      },
      "source": [
        "\n",
        "## Usando (1) e um loop for\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 129,
      "id": "f7849a73",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "f7849a73"
      },
      "outputs": [],
      "source": [
        "def previsao_usando_loop_for(x, w, b):\n",
        "    \"\"\"\n",
        "    faz uma previsão usando loop for\n",
        "\n",
        "    Args:\n",
        "      x (ndarray): Shape (n,) -> exemplo contendo múltiplas características\n",
        "      w (ndarray): Shape (n,) -> parâmetros w do modelo\n",
        "      b (scalar):  parâmetro b do modelo\n",
        "\n",
        "    retorna:\n",
        "      p (scalar):  previsão\n",
        "    \"\"\"\n",
        "    n = x.shape[0]\n",
        "    p = 0\n",
        "    for i in range(n):\n",
        "        p_i = x[i] * w[i]\n",
        "        p = p + p_i\n",
        "    p = p + b\n",
        "    return p"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 130,
      "id": "97516175",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "97516175",
        "outputId": "13712a49-3fbe-476c-da52-6b605882e836"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "x_vetor shape (4,), x_vec: [2104    5    1   45]\n",
            "f_wb shape (), previsão: 459.9999976194083\n"
          ]
        }
      ],
      "source": [
        "# pegando uma linha do nosso conjunto de dados\n",
        "x_vetor = X_trein[0,:]\n",
        "print(f\"x_vetor shape {x_vetor.shape}, x_vec: {x_vetor}\")\n",
        "\n",
        "# fazendo previsão para essa casa\n",
        "f_wb = previsao_usando_loop_for(x_vetor, w_inicial, b_inicial)\n",
        "print(f\"f_wb shape {f_wb.shape}, previsão: {f_wb}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3475821f",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "3475821f"
      },
      "source": [
        "Note que o shape do `x_vetor` é 1-D com 4 elementos, ou seja, (4,). Já o resultado da previsão, `f_wb`, é um escalar."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2f4f4c5d",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "2f4f4c5d"
      },
      "source": [
        "\n",
        "## Usando (2) e o produto escalar para termos uma versão vetorizada"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 131,
      "id": "c2766634",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "c2766634"
      },
      "outputs": [],
      "source": [
        "def previsao(x, w, b):\n",
        "    \"\"\"\n",
        "    Argumentos da função:\n",
        "      x (ndarray): Shape (n,) -> exemplo contendo múltiplas características\n",
        "      w (ndarray): Shape (n,) -> parâmetros w do modelo\n",
        "      b (escalar):  parâmetro b do modelo\n",
        "\n",
        "    retorna:\n",
        "      p (escalar):  previsão\n",
        "    \"\"\"\n",
        "    p = np.dot(x, w) + b\n",
        "    return p"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 132,
      "id": "aaa8a90a",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aaa8a90a",
        "outputId": "f43deab4-cd86-421a-fb91-7ee7bdf092a7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "x_vetor shape (4,), x_vec: [2104    5    1   45]\n",
            "f_wb shape (), previsão: 459.9999976194083\n"
          ]
        }
      ],
      "source": [
        "# pegando uma linha do nosso conjunto de dados\n",
        "x_vetor = X_trein[0,:]\n",
        "print(f\"x_vetor shape {x_vetor.shape}, x_vec: {x_vetor}\")\n",
        "\n",
        "# fazendo previsão para essa casa\n",
        "f_wb = previsao(x_vetor, w_inicial, b_inicial)\n",
        "print(f\"f_wb shape {f_wb.shape}, previsão: {f_wb}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Note que o resultado é igual ao obtido anteriormente, pois trata-se da mesma casa e do mesmo modelo de previsão. Entretanto, a implementação vetorizada (com redução de laços do tipo `for') é mais elegante e menos custosa computacionalmente."
      ],
      "metadata": {
        "id": "S9XweHHVL7rr"
      },
      "id": "S9XweHHVL7rr"
    },
    {
      "cell_type": "markdown",
      "id": "c848f0ba",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "c848f0ba"
      },
      "source": [
        "# Calculando o custo quando o modelo possui múltiplas características\n",
        "A função custo $J(\\mathbf{w},b)$ quando temos múltiplas características é dada por:\n",
        "$$J(\\mathbf{w},b) = \\frac{1}{2m} \\sum\\limits_{i = 0}^{m-1} (f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}) - y^{(i)})^2 \\tag{3}$$\n",
        "onde:\n",
        "$$ f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}) = \\mathbf{w} \\cdot \\mathbf{x}^{(i)} + b  \\tag{4} $$\n",
        "\n",
        "\n",
        "Diferentemente dos nossos códigos anteriores, agora $\\mathbf{w}$ e $\\mathbf{x}^{(i)}$ são vetores ao invés de escalares."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f1b5fc8c",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "f1b5fc8c"
      },
      "source": [
        "Abaixo encontram-se uma implementação das equações (3) and (4)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 133,
      "id": "0ec89357",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "0ec89357"
      },
      "outputs": [],
      "source": [
        "def calcula_custo(X, y, w, b):\n",
        "    \"\"\"\n",
        "    Calcula o custo\n",
        "    Argumentos da função:\n",
        "      X (ndarray (m,n)): Dados, contendo m exemplos com n características\n",
        "      y (ndarray (m,)) : valores alvo\n",
        "      w (ndarray (n,)) : parâmetros w do modelo\n",
        "      b (escalar)       : parâmetro b do modelo\n",
        "\n",
        "    Retorna:\n",
        "      custo (escalar): custo\n",
        "    \"\"\"\n",
        "    m     = X.shape[0]\n",
        "    custo = 0.0\n",
        "    for i in range(m):\n",
        "        f_wb_i = np.dot(X[i], w) + b           #(n,)(n,) = escalar (see np.dot)\n",
        "        custo = custo + (f_wb_i - y[i])**2     # escalar\n",
        "    custo = custo / (2 * m)                    # escalar\n",
        "    return custo"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 134,
      "id": "652c5388",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "652c5388",
        "outputId": "f5ca0b16-2c60-4250-be4f-a3601a3087ea"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Custo com parâmetros ótimos: 1.5578904428966628e-12\n"
          ]
        }
      ],
      "source": [
        "# Calcula e mostra o custo usando os nossos parâmetros ótimos escolhidos previamente\n",
        "custo = calcula_custo(X_trein, y_trein, w_inicial, b_inicial)\n",
        "print(f'Custo com parâmetros ótimos: {custo}')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "49f3c105",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "49f3c105"
      },
      "source": [
        "**Resultado esperado**: 1.5578904045996674e-12"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4d998888",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "4d998888"
      },
      "source": [
        "# Método do Gradiente com Múltiplas Variáveis\n",
        "\n",
        "Método do Gradiente com Múltiplas Variáveis:\n",
        "\n",
        "$$\\begin{align*} \\text{repetir}&\\text{ até convergir:} \\; \\lbrace \\newline\\;\n",
        "& w_j = w_j -  \\alpha \\frac{\\partial J(\\mathbf{w},b)}{\\partial w_j} \\tag{5}  \\; & \\text{para j = 0..n-1}\\newline\n",
        "&b\\ \\ = b -  \\alpha \\frac{\\partial J(\\mathbf{w},b)}{\\partial b}  \\newline \\rbrace\n",
        "\\end{align*}$$\n",
        "\n",
        "onde, n é o número de características, parâmetros $w_j$ e $b$ são atualizados simultaneamente e onde  \n",
        "\n",
        "$$\n",
        "\\begin{align}\n",
        "\\frac{\\partial J(\\mathbf{w},b)}{\\partial w_j}  &= \\frac{1}{m} \\sum\\limits_{i = 0}^{m-1} (f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}) - y^{(i)})x_{j}^{(i)} \\tag{6}  \\\\\n",
        "\\frac{\\partial J(\\mathbf{w},b)}{\\partial b}  &= \\frac{1}{m} \\sum\\limits_{i = 0}^{m-1} (f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}) - y^{(i)}) \\tag{7}\n",
        "\\end{align}\n",
        "$$\n",
        "* m é o número de amostras de treinamento no nosso conjunto de dados\n",
        "\n",
        "    \n",
        "*  $f_{\\mathbf{w},b}(\\mathbf{x}^{(i)})$ é a previsão feita pelo modelo, enquanto que $y^{(i)}$ é o valor alvo\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "72c7ab1b",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "72c7ab1b"
      },
      "source": [
        "## Calculando o gradiente\n",
        "\n",
        "Abaixo encontra-se uma implementação para calcular as equações (6) e (7). Existe muitas formas para se implementar isso. Certifique-se que você compreendeu a implementação.\n",
        "   "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 135,
      "id": "f0f29948",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "f0f29948"
      },
      "outputs": [],
      "source": [
        "def calcula_gradiente(X, y, w, b):\n",
        "    \"\"\"\n",
        "    Calcula Gradiente para Regressão Linear\n",
        "    Argumentos:\n",
        "      X (ndarray (m,n)): Dados, contendo m exemplos com n características\n",
        "      y (ndarray (m,)) : valores alvo\n",
        "      w (ndarray (n,)) : parâmetros w do modelo\n",
        "      b (escalar)      : parâmetro b do modelo\n",
        "\n",
        "    Retorna:\n",
        "      dj_dw (ndarray (n,)): O gradiente da função custo com relação aos parâmetros w.\n",
        "      dj_db (escalar):      O gradiente da função custo com relação ao parâmetro b.\n",
        "    \"\"\"\n",
        "    m,n = X.shape           #(número de exemplos, número de características)\n",
        "    dj_dw = np.zeros((n,))\n",
        "    dj_db = 0.\n",
        "\n",
        "    for i in range(m):\n",
        "        erro = (np.dot(X[i], w) + b) - y[i]\n",
        "        for j in range(n):\n",
        "            dj_dw[j] = dj_dw[j] + erro * X[i, j]\n",
        "        dj_db = dj_db + erro\n",
        "    dj_dw = dj_dw / m\n",
        "    dj_db = dj_db / m\n",
        "\n",
        "    return dj_db, dj_dw"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 136,
      "id": "839b5e62",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "839b5e62",
        "outputId": "e85effbb-8d26-40f3-b31c-29268ba30ad2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dj_db com valores iniciais para w,b: -1.6739251501955248e-06\n",
            "dj_dw com valores iniciais para w,b: \n",
            " [-2.73e-03 -6.27e-06 -2.22e-06 -6.92e-05]\n"
          ]
        }
      ],
      "source": [
        "# Calcula e mostra o gradiente\n",
        "tmp_dj_db, tmp_dj_dw = calcula_gradiente(X_trein, y_trein, w_inicial, b_inicial)\n",
        "print(f'dj_db com valores iniciais para w,b: {tmp_dj_db}')\n",
        "print(f'dj_dw com valores iniciais para w,b: \\n {tmp_dj_dw}')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "426cbe05",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "426cbe05"
      },
      "source": [
        "**Resultados Esperados**:   \n",
        "dj_db com valores iniciais w,b: -1.6739251122999121e-06  \n",
        "dj_dw com valores iniciais w,b:   \n",
        " [-2.73e-03 -6.27e-06 -2.22e-06 -6.92e-05]  "
      ]
    },
    {
      "cell_type": "markdown",
      "id": "03b1937a",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "03b1937a"
      },
      "source": [
        "## Método do Gradiente com múltiplas características\n",
        "\n",
        "A rotina a seguir implementa a equação (5)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 137,
      "id": "e95f471c",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "e95f471c"
      },
      "outputs": [],
      "source": [
        "def metodo_do_gradiente(X, y, w_in, b_in, calcula_custo, calcula_gradiente, alpha, num_iters):\n",
        "    \"\"\"\n",
        "    Performa Método do Gradiente para aprender w e b. Atualiza w e b ao longo de\n",
        "    num_iters iterações usando uma taxa de aprendizado alpha\n",
        "\n",
        "    Argumentos da função:\n",
        "      X (ndarray (m,n))   : Dados, contendo m exemplos com n características\n",
        "      y (ndarray (m,))    : valores alvo\n",
        "      w_in (ndarray (n,)) : valores iniciais dos parâmetros w do modelo\n",
        "      b_in (escalar)      : valor inicial do parâmetro b do modelo\n",
        "      calcula_custo       : função que calcula o custo\n",
        "      calcula_gradiente   : função que calcula o gradiente\n",
        "      alpha (float)       : taxa de aprendizado\n",
        "      num_iters (int)     : Número de iterações para o método do gradiente\n",
        "\n",
        "    Retorna:\n",
        "      w (ndarray (n,)) : Valores atualizados para os parâmetros w\n",
        "      b (scalar)       : Valores atualizado para o parâmetro b\n",
        "      \"\"\"\n",
        "\n",
        "    # Valores históricos\n",
        "    J_history = []\n",
        "    w = w_in\n",
        "    b = b_in\n",
        "\n",
        "    for i in range(num_iters):\n",
        "\n",
        "        # Calcula o gradiente\n",
        "        dj_db,dj_dw = calcula_gradiente(X, y, w, b)\n",
        "\n",
        "        # Atualiza os parâmetros\n",
        "        w = w - alpha * dj_dw\n",
        "        b = b - alpha * dj_db\n",
        "\n",
        "        # Salva o custo\n",
        "        if i<100000:      # prevent resource exhaustion\n",
        "            J_history.append( calcula_custo(X, y, w, b))\n",
        "\n",
        "        # Faz print de tempos em tempos\n",
        "        if i% math.ceil(num_iters / 10) == 0:\n",
        "            print(f\"Iteração {i:4d}: Custo {J_history[-1]:8.2f}   \")\n",
        "\n",
        "    return w, b, J_history # retorna valores finais e históricos"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0fc222a6",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "0fc222a6"
      },
      "source": [
        "Na célula a seguir testamos a implementação"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 138,
      "id": "3a5ac992",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3a5ac992",
        "outputId": "70b749ea-f32b-4f9c-fb71-747049f81f55"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Iteração    0: Custo   444.75   \n",
            "Iteração 10000: Custo   443.35   \n",
            "Iteração 20000: Custo   442.30   \n",
            "Iteração 30000: Custo   441.25   \n",
            "Iteração 40000: Custo   440.21   \n",
            "Iteração 50000: Custo   439.17   \n",
            "Iteração 60000: Custo   438.13   \n",
            "Iteração 70000: Custo   437.09   \n",
            "Iteração 80000: Custo   436.06   \n",
            "Iteração 90000: Custo   435.03   \n",
            "b,w encontrados pelo método do gradiente: 0.11,[ 0.23  3.12 -8.78 -1.18] \n",
            "previsão: 441.96, valor alvo: 460\n",
            "previsão: 273.25, valor alvo: 232\n",
            "previsão: 153.99, valor alvo: 178\n"
          ]
        }
      ],
      "source": [
        "# inicializando parâmetros\n",
        "w_inicial = np.zeros_like(w_inicial)\n",
        "b_inicial = 0\n",
        "\n",
        "w_inicial =[0.23, 2.88, -8.1, -1.21]\n",
        "b_inicial = 0.10\n",
        "\n",
        "#0.09,[ 0.23  2.63 -7.41 -1.25]\n",
        "\n",
        "# parâmetros para rodar o Método do Gradiente:\n",
        "num_iters = 100000\n",
        "alpha     = 5.0e-7\n",
        "# Rodando o Método do gradiente\n",
        "w_final, b_final, J_hist = metodo_do_gradiente(X_trein, y_trein, w_inicial, b_inicial,\n",
        "                                                    calcula_custo, calcula_gradiente,\n",
        "                                                    alpha, num_iters)\n",
        "print(f\"b,w encontrados pelo método do gradiente: {b_final:0.2f},{w_final} \")\n",
        "m,_ = X_trein.shape\n",
        "for i in range(m):\n",
        "    print(f\"previsão: {np.dot(X_trein[i], w_final) + b_final:0.2f}, valor alvo: {y_trein[i]}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 139,
      "id": "06159dde",
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 428
        },
        "id": "06159dde",
        "outputId": "cea03d0e-c440-457d-9f5a-18960f86374d"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x400 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Plotando os resultados\n",
        "fig, (ax1, ax2) = plt.subplots(1, 2, constrained_layout=True, figsize=(12, 4))\n",
        "ax1.plot(J_hist)\n",
        "ax2.plot(100 + np.arange(len(J_hist[100:])), J_hist[100:])\n",
        "ax1.set_title(\"Custo vs. iteração\");  ax2.set_title(\"Custo vs. iteração (cauda do gráfico)\")\n",
        "ax1.set_ylabel('Custo')             ;  ax2.set_ylabel('Custo')\n",
        "ax1.set_xlabel('iteração')   ;  ax2.set_xlabel('iteração')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1e01cf89",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "1e01cf89"
      },
      "source": [
        "*Estes resultados ainda não são os melhores*! O custo ainda está caindo e nossas previsões não estão tão precisas. No próximo código nós vamos descobrir como melhorar isso."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d7b12e72",
      "metadata": {
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "d7b12e72"
      },
      "source": [
        "# Parabéns!\n",
        "Com este código você:\n",
        "- Redesenvolveu as rotinas para Regressão Linear, agora com múltiplas variáveis.\n",
        "- Utilizou NumPy `np.dot` para vetorizar as implementações"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Parte 2 Resolução de questões:\n",
        "\n",
        "### a) Valores obtidos para w e b:\n",
        "b = -0.00\n",
        "w = [ 0.20, 0.00, -0.01, -0.07 ]\n",
        "\n",
        "### b) Observação:\n",
        "Esses valores não representam necessariamente o mínimo global.\n",
        "É possível que sejam apenas um mínimo local, dependendo da função de custo e do ponto inicial da otimização.\n",
        "\n"
      ],
      "metadata": {
        "id": "Etcxk40X7whu"
      },
      "id": "Etcxk40X7whu"
    }
  ],
  "metadata": {
    "dl_toc_settings": {
      "rndtag": "15456"
    },
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.12"
    },
    "toc-autonumbering": false,
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}